package com.erp.gather.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.Dict;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.erp.gather.mapper.ErpKakaCollectProductUploadTestTaskMapper;
import com.erp.gather.service.IErpKakaCollectProductUploadTestTaskService;
import com.ruoyi.ae.api.RemoteAeStoreInfoService;
import com.ruoyi.ae.api.domain.AeProductPost;
import com.ruoyi.collect.api.domain.ErpKakaCollectProduct;
import com.ruoyi.collect.api.domain.ErpKakaCollectProductExpand;
import com.ruoyi.collect.api.domain.ErpKakaCollectProductSku;
import com.ruoyi.collect.api.domain.ErpKakaCollectProductUploadTestTask;
import com.ruoyi.collect.api.domain.bo.ErpKakaCollectProductUploadTestTaskBo;
import com.ruoyi.collect.api.domain.vo.ErpKakaCollectProductUploadTestTaskVo;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.utils.JsonUtils;
import com.ruoyi.common.core.utils.oldUtils.StringUtils;
import com.ruoyi.common.core.web.oldPage.TableDataInfo;
import com.ruoyi.gather.api.RemoteProductCategoryBrandService;
import com.ruoyi.gather.api.domain.Aliexpress;
import com.ruoyi.gather.api.domain.ErpCollectProduct;
import com.ruoyi.gather.api.domain.ErpCollectProductSku;
import com.ruoyi.shop.api.RemoteSellerStoreService;
import com.ruoyi.shop.api.domain.ErpSellerStoreEmpower;
import com.ruoyi.shop.api.domain.ErpSellerStoreEmpowerExtend;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 采集商品上传测试任务Service业务层处理
 *
 * @author erp
 * @date 2023-05-18
 */
@RequiredArgsConstructor
@Service
public class ErpKakaCollectProductUploadTestTaskServiceImpl implements IErpKakaCollectProductUploadTestTaskService {

    private final ErpKakaCollectProductUploadTestTaskMapper baseMapper;
    private final RemoteProductCategoryBrandService remoteProductCategoryBrandService;
    private final RemoteAeStoreInfoService remoteAeStoreInfoService;
    private final RemoteSellerStoreService remoteSellerStoreService;

    /**
     * 查询采集商品上传测试任务
     */
    @Override
    public ErpKakaCollectProductUploadTestTaskVo queryById(Long id) {
        return baseMapper.selectVoById(id);
    }

    /**
     * 查询采集商品上传测试任务列表
     */
    @Override
    public TableDataInfo<ErpKakaCollectProductUploadTestTaskVo> queryPageList(ErpKakaCollectProductUploadTestTaskBo bo, PageQuery pageQuery) {
        LambdaQueryWrapper<ErpKakaCollectProductUploadTestTask> lqw = buildQueryWrapper(bo);
        Page<ErpKakaCollectProductUploadTestTaskVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
        return TableDataInfo.build(result);
    }

    /**
     * 查询采集商品上传测试任务列表
     */
    @Override
    public List<ErpKakaCollectProductUploadTestTaskVo> queryList(ErpKakaCollectProductUploadTestTaskBo bo) {
        LambdaQueryWrapper<ErpKakaCollectProductUploadTestTask> lqw = buildQueryWrapper(bo);
        return baseMapper.selectVoList(lqw);
    }

    private LambdaQueryWrapper<ErpKakaCollectProductUploadTestTask> buildQueryWrapper(ErpKakaCollectProductUploadTestTaskBo bo) {
        Map<String, Object> params = bo.getParams();
        LambdaQueryWrapper<ErpKakaCollectProductUploadTestTask> lqw = Wrappers.lambdaQuery();
        lqw.eq(bo.getCollectProductId() != null, ErpKakaCollectProductUploadTestTask::getCollectProductId, bo.getCollectProductId());
        lqw.eq(bo.getStoreId() != null, ErpKakaCollectProductUploadTestTask::getStoreId, bo.getStoreId());
        lqw.eq(bo.getStatus() != null, ErpKakaCollectProductUploadTestTask::getStatus, bo.getStatus());
        lqw.eq(bo.getAddTime() != null, ErpKakaCollectProductUploadTestTask::getAddTime, bo.getAddTime());
        return lqw;
    }

    /**
     * 新增采集商品上传测试任务
     */
    @Override
    public Boolean insertByBo(ErpKakaCollectProductUploadTestTaskBo bo) {
        ErpKakaCollectProductUploadTestTask add = BeanUtil.toBean(bo, ErpKakaCollectProductUploadTestTask.class);
        validEntityBeforeSave(add);
        bo.setType("1");
        boolean flag = baseMapper.insert(add) > 0;
        if (flag) {
            bo.setId(add.getId());
        }
        return flag;
    }

    /**
     * 修改采集商品上传测试任务
     */
    @Override
    public Boolean updateByBo(ErpKakaCollectProductUploadTestTaskBo bo) {
        ErpKakaCollectProductUploadTestTask update = BeanUtil.toBean(bo, ErpKakaCollectProductUploadTestTask.class);
        validEntityBeforeSave(update);
        return baseMapper.updateById(update) > 0;
    }

    /**
     * 保存前的数据校验
     */
    private void validEntityBeforeSave(ErpKakaCollectProductUploadTestTask entity) {
        //TODO 做一些数据校验,如唯一约束
    }

    /**
     * 批量删除采集商品上传测试任务
     */
    @Override
    public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
        if (isValid) {
            //TODO 做一些业务上的校验,判断是否需要校验
        }
        return baseMapper.deleteBatchIds(ids) > 0;
    }

    @Override
    public List<ErpKakaCollectProductUploadTestTask> queryWaitUploadProductList() {
        List<ErpKakaCollectProductUploadTestTask> ErpKakaCollectProductUploadTestTasks = baseMapper.selectList(
                new LambdaQueryWrapper<ErpKakaCollectProductUploadTestTask>()
                        .eq(ErpKakaCollectProductUploadTestTask::getStatus, 0)
        );
        return ErpKakaCollectProductUploadTestTasks;
    }

//
//    /**
//     * 进行测试发布流程
//     *
//     * @param task
//     * @param type
//     * @param
//     * @param expand
//     * @param skuList
//     * @return
//     */
//
//    @Override
//    public ErpKakaCollectProductUploadTestTask disposeKakaUploadTest(ErpKakaCollectProductUploadTestTask task,
//                                                                     Integer type,
//                                                                     ErpKakaCollectProduct productTest,
//                                                                     ErpKakaCollectProductExpand expand,
//                                                                     List<ErpKakaCollectProductSku> skuList) {
//        // 2、获取有权限的店铺账号
//        List<Long> sellerStoreList = remoteProductCategoryBrandService.getCategoryTreeListForStore(productTest.getCategoryId());
//        if (sellerStoreList == null) {
//            task.setRemark("没有店铺可供测试");
//            task.setStatus(4);
//            return task;
//        }
//
//        for (Long sellerStoreId : sellerStoreList) {
//
//            HashMap<String, Object> storeMap = new HashMap<>();
//            storeMap.put("sellerId", sellerStoreId);
//            //判断当前店铺是否有授权
//            R<Object> objectR1 = remoteAeStoreInfoService.querySellerStoreInfo(sellerStoreId.toString());
//            if (objectR1.getCode() != 200) {
//                task.setRemark("测试店铺未授权");
//                task.setStatus(3);
//                continue;
//            }
//
//            //防止上轮循环影响
//            ErpKakaCollectProduct product = BeanUtil.toBean(productTest, ErpKakaCollectProduct.class);
//
//            task.setStoreId(sellerStoreId);
//            // 有权限店铺
//            R<Object> objectR = remoteSellerStoreService.getSellerStoreInfoById(Long.valueOf(sellerStoreId));
//            String toJSONString = JSONObject.toJSONString(objectR.getData());
//            ErpSellerStoreEmpower storeEmpower = JSONObject.parseObject(toJSONString, ErpSellerStoreEmpower.class);
//            if (storeEmpower == null || !storeEmpower.getIsEmpower().equals("1")) {
//                task.setRemark("测试店铺未授权");
//                task.setStatus(3);
//                continue;
////                return task;
//            }
//
//            //判断店铺有无权限
//            List<Aliexpress.ValueVo> brandById = aliexpressCategoryService.getBrandById(product.getCategoryId(), sellerStoreId);
//            if (brandById.size() == 0) {
//                task.setRemark("测试店铺没有该类目的品牌");
//                task.setStatus(3);
//                continue;
//            }
//
//            // 有权限店铺延伸
//            ErpSellerStoreEmpowerExtend storeExtendSel = new ErpSellerStoreEmpowerExtend();
//            storeExtendSel.setSellerId(sellerStoreId);
//            R<Object> storeExtendObject = remoteSellerStoreService.getSellerStoreExtendInfo(storeExtendSel);
//            String storeExtendString = JSONObject.toJSONString(storeExtendObject.getData());
//            storeExtendSel = JSONObject.parseObject(storeExtendString, ErpSellerStoreEmpowerExtend.class);
//
//            // 5、填入信息
//            Map<String, Object> map = new HashMap<>();
//            try {
//                Integer code = (Integer) map.get("code");
//                map = updateSkuProperty(product, skuList, expand);
//                if (code != 200) {
//                    task.setRemark(map.get("errorMsg") + "");
//                    task.setStatus(3);
//                    baseMapper.updateById(task);
//                    continue;
////                    return task;
//                }
//            } catch (Exception e) {
//                task.setRemark("Sku属性异常");
//                task.setStatus(3);
//                baseMapper.updateById(task);
//                continue;
////                return task;
//            }
//            product = (ErpKakaCollectProduct) map.get("product");
//            expand = (ErpKakaCollectProductExpand) map.get("expand");
//            try {
//                map = getErpProductInfo(product, expand, storeEmpower, storeExtendSel, skuList, task, type);
//                Integer code = (Integer) map.get("code");
//                if (code != 200) {
//                    task = (ErpKakaCollectProductUploadTestTask) map.get("uploadTestTask");
//                    task.setStatus(3);
//                    baseMapper.updateById(task);
//                    continue;
////                    return task;
//                }
//            } catch (Exception e) {
//                task.setRemark("商品基本信息异常，待排查");
//                task.setStatus(3);
//                baseMapper.updateById(task);
//                continue;
////                return task;
//            }
//
//            JSONObject json = new JSONObject(map);
//            System.out.println(json);
//
//            // 发往Ae测试
//            forEntity = restTemplate
//                    .postForEntity(aeConfig.getEndpoint() + "/erp/erpProduct/uploadProductTest", map, String.class);
//            // 6、发送给Ae,得到上传结果
//            body = (String) forEntity.getBody();
//            String msgCode = JSONObject.parseObject(body).getString("code");
//            if (!msgCode.equals("200")) {
//                // 分析返回请求
//                String errorCode = JSONObject.parseObject(body).getJSONObject("msg").getJSONObject("error_response")
//                        .getString("sub_code");
//                if (errorCode != null) {
//                    // 查找错误编码确认对应错误
//                    AeProductPostError error = iAeProductPostErrorService.selectByErrorCode(errorCode);
//                    if (error != null) {
//                        // 记录错误
//                        task.setRemark(error.getErrorReason());
//                        task.setStatus(3);
//                    } else {
//                        String sub_msg = JSONObject.parseObject(body).getJSONObject("msg")
//                                .getJSONObject("error_response").getString("sub_msg");
//                        // 记录错误
//                        task.setRemark(sub_msg);
//                        task.setStatus(3);
//                    }
//                } else {
//                    // 记录错误
//                    task.setRemark(JSONObject.parseObject(body).getJSONObject("msg").getJSONObject("error_response")
//                            .getString("msg"));
//                    task.setStatus(3);
//                }
//                if (task.getRemark().equals("该店铺没有此类目发布权限") || task.getRemark().equals("测试店铺没有该类目的品牌")) {
//                    continue;
//                } else {
//                    break;
//                }
//            } else {
//                // 新增商品成功
//                Long aeProductId = JSONObject.parseObject(body).getJSONObject("msg")
//                        .getJSONObject("aliexpress_offer_product_post_response").getJSONObject("result")
//                        .getLong("product_id");
//                task.setRemark("测试成功");
//                task.setStatus(2);
//                // 7、下架产品Long sellerStoreProductIds, Long sellerId, Integer type
//                aeProductService.productOfflineForUpdateTest(aeProductId.toString(), storeEmpower.getId(), type);
//
//                // 8、删除产品
//                aeProductService.deleteProductToAe(aeProductId, storeEmpower.getId());
//            }
//            break;
//        }
//
//        return task;
//    }
//
//
//    // 修改店铺sku属性和区域定价
//    public Map<String, Object> updateSkuProperty(ErpKakaCollectProduct product, List<ErpKakaCollectProductSku> skuList,
//                                                 ErpKakaCollectProductExpand expand) {
//        Map<String, Object> map = new HashMap<>();
//        map.put("code", 200);
//        Long categoryId = product.getCategoryId();
//
//        // 根据类目获取所需的sku属性
//        Map<Integer, List<Integer>> skuPropertyMap = aliexpressCategoryService.getSkuPropertyById(categoryId);
//
//        System.out.println(" skuPropertyMap :" + JsonUtils.toJsonString(skuPropertyMap));
//
//        // 获取商品爬取的sku属性
//        String skuProperty = expand.getSkuProperty();
//        List<Dict> skuPropertyList = JsonUtils.parseArrayMap(skuProperty);
//
//        // 替换值map
//        Map<Integer, Integer> thNameMap = new HashMap<>();
//        Map<Integer, Integer> thValueMap = new HashMap<>();
//        List<Integer> nameIdList = new ArrayList<>(skuPropertyMap.keySet());
//
//        if (skuPropertyMap.size() < skuPropertyList.size()) {
//            map.put("code", 500);
//            String msg = "速卖通类目规格为：" + skuPropertyMap.size() + "个，erp商品规格个数为：" + skuPropertyList.size() + "个，请手动合并规格。";
//            map.put("errorMsg", msg);
//            return map;
//        }
//
//
//        for (int i = 0; i < skuPropertyList.size(); i++) {
//            Dict dict = skuPropertyList.get(i);
//            Integer oldNameId = (Integer) dict.get("value");
//            String name = (String) dict.get("name");
//
//            // 替换PropertyValue
//            Integer nameId = nameIdList.get(i);
//            dict.set("value", nameId);
//            thNameMap.put(oldNameId, nameId);
//
//            List<Integer> valueIdList = skuPropertyMap.get(nameId);
//            // 获取值Value
//            List<HashMap<String, Object>> valueList = (List<HashMap<String, Object>>) dict.get("list");
//            if (valueIdList.size() < valueList.size()) {
//                map.put("code", 503);
//                map.put("errorMsg",
//                        "属性：" + name + "在速卖通可选值为" + valueIdList.size() + "个，当前个数为" + valueList.size() + "个，超出备选个数！");
//                return map;
//            }
//            for (int j = 0; j < valueList.size(); j++) {
//                HashMap<String, Object> valueMap = valueList.get(j);
//                Integer oldValueId = (Integer) valueMap.get("value");
//                // 替换
//                Integer valueId = valueIdList.get(j);
//                valueMap.put("value", valueId);
//                thValueMap.put(oldValueId, valueId);
//            }
//        }
//        skuProperty = JsonUtils.toJsonString(skuPropertyList);
//        expand.setSkuProperty(skuProperty);
//
//        // 获取sku
//        Map<String, String> thPopertyIdsMap = new HashMap<>();
//        for (ErpKakaCollectProductSku erpCollectProductSku : skuList) {
//            String skuPropertyIds = erpCollectProductSku.getSkuPropertyIds();
//
//            String skuPropertyIdsNew = "";
//            // 切割字符串，替换
//            String[] split = skuPropertyIds.split(";");
//            for (String s : split) {
//                String[] split2 = s.split(":");
//                String nameId = split2[0];
//                String valueId = split2[1];
//                // 替换
//                Integer newNameId = thNameMap.get(Integer.valueOf(nameId));
//                Integer newValueIdId = thValueMap.get(Integer.valueOf(valueId));
//
//                skuPropertyIdsNew += newNameId + ":" + newValueIdId + ";";
//            }
//
//            // 切割掉最后的","
//            skuPropertyIdsNew = skuPropertyIdsNew.substring(0, skuPropertyIdsNew.lastIndexOf(";"));
//            erpCollectProductSku.setSkuPropertyIds(skuPropertyIdsNew);
//
//            thPopertyIdsMap.put(skuPropertyIds, skuPropertyIdsNew);
//        }
//
//        // 最后替换运费试算
//        String freightMap = expand.getFreightMap();
//        if (ObjectUtils.isNotNull(freightMap)) {
//            List<Dict> freightMapList = JsonUtils.parseArrayMap(freightMap);
//            for (Dict dict : freightMapList) {
//                Map<String, Object> absoluteQuoteMap = (Map) dict.get("absoluteQuoteMap");
//                Map<String, Double> absoluteQuoteMapNew = new HashMap<>();
//                for (String key : absoluteQuoteMap.keySet()) {
//                    String newKey = thPopertyIdsMap.get(key);
//                    Double object = Double.valueOf(absoluteQuoteMap.get(key).toString());
//                    if (StringUtils.isNotEmpty(newKey))
//                        absoluteQuoteMapNew.put(newKey, object);
//                    else
//                        absoluteQuoteMapNew.put(key, object);
//                }
//                dict.put("absoluteQuoteMap", absoluteQuoteMapNew);
//            }
//
//            // 获取完成的运费试算
//            freightMap = JsonUtils.toJsonString(freightMapList);
//            expand.setFreightMap(freightMap);
//
//            Map<String, BigDecimal> skuMap = new HashMap<>();
//            try {
//                skuList.forEach(sku -> skuMap.put(sku.getSkuPropertyIds(),
//                        new BigDecimal(sku.getSkuPrice()).multiply(new BigDecimal(1.1))));
//            } catch (Exception e) {
//                map.put("code", 504);
//                map.put("errorMsg", "sku运费试算异常，请重新将此商品进行运费试算");
//                return map;
//            }
//
//            Double min = null;
//            Double max = null;
//
//            // 获取运费，修改金额
//            for (Dict dict : freightMapList) {
//                Map<String, Object> absoluteQuoteMap = (Map) dict.get("absoluteQuoteMap");
//                for (String key : absoluteQuoteMap.keySet()) {
//                    BigDecimal amount = new BigDecimal(absoluteQuoteMap.get(key).toString());
//
//                    // 获取sku
//                    BigDecimal skuPrice = skuMap.get(key);
//
//                    // 计算最终价格
//                    amount = skuPrice.add(amount).setScale(2, BigDecimal.ROUND_HALF_UP);
//                    Double res = amount.doubleValue();
//                    absoluteQuoteMap.put(key, res);
//                    if (min == null || res < min)
//                        min = res;
//                    if (max == null || res > max)
//                        max = res;
//                }
//            }
//
//            // 获取完成的区域定价
//            String absoluteQuoteMap = JsonUtils.toJsonString(freightMapList);
//            expand.setAbsoluteQuoteMap(absoluteQuoteMap);
//            product.setProductPrice(min.equals(max) ? min + "" : min + "-" + max);
//        }
//
//
//        // 修改商品的价格
//        product.setId(product.getId());
//
//        map.put("product", product);
//        map.put("expand", expand);
//        return map;
//    }
//
//    // 获取产品信息
//    public Map<String, Object> getErpProductInfo(ErpKakaCollectProduct product, ErpKakaCollectProductExpand expend,
//                                                 ErpSellerStoreEmpower storeEmpower, ErpSellerStoreEmpowerExtend storeEmpowerExtend,
//                                                 List<ErpKakaCollectProductSku> skuList, ErpKakaCollectProductUploadTestTask uploadTestTask,
//                                                 Integer type
//
//    ) {
//        AeProductPost aeProductPost = new AeProductPost();
//        Map<String, Object> map = new HashMap<>();
//        // 当前类目
//        Long categoryId = product.getCategoryId();
//        // 店铺账号
//        Long storeId = storeEmpower.getId();
//        // 美金/人民币店铺
//        String quotationCurrency = storeEmpowerExtend.getQuotationCurrency();
//        // 语言
//        map.put("locale", "en_US");
//        // 支付策略
//        map.put("reduce_strategy", "payment_success_deduct");
//        // 币种
//        if (storeEmpowerExtend.getQuotationCurrency() != null) {
//            map.put("currency_code", quotationCurrency);
//        } else {
//            map.put("currency_code", "USD");
//        }
//        // 备货期
//        map.put("delivery_time", expend.getDeliveryTime());
//        // 购买几件以内不增加运费
//        map.put("base_unit", expend.getBaseUnit());
//        // 是否自定义计重
//        map.put("is_pack_sell", expend.getIsPackSell());
//        // 打包销售
//        map.put("package_type", expend.getPackageType());
//        // 每增加件数
//        map.put("add_unit", expend.getAddUnit());
//        // 对应增加的重量
//        map.put("add_weight", expend.getAddWeight());
//        // 每包件数
//        map.put("lot_num", expend.getLotNum());
//        try {
//            // 商品毛重
//            Double grossWeight = Double.valueOf(product.getGrossWeight()) / 1000;
//            map.put("gross_weight", grossWeight);
//            // 商品包装宽度
//            map.put("package_width", Integer.valueOf(product.getPackageWidth()));
//            // 商品包装高度
//            map.put("package_height", product.getPackageHeight().intValue());
//            // 商品包装长度
//            map.put("package_length", product.getPackageLength().intValue());
//        } catch (Exception e) {
//            uploadTestTask.setRemark("商品长宽高重量不为整数");
//            uploadTestTask.setStatus(3);
//            map.put("uploadTestTask", uploadTestTask);
//            map.put("code", 500);
//            return map;
//        }
//
//        // 产品id
//        map.put("category_id", categoryId);
//
//        map.put("storeId", storeId);
//
//        // 服务模板
//        LambdaQueryWrapper<ErpSellerStorePromiseTemplate> proLqw = new LambdaQueryWrapper<ErpSellerStorePromiseTemplate>();
//        proLqw.eq(ErpSellerStorePromiseTemplate::getSellerStoreId, storeId);
//        proLqw.last("limit 1");
//        ErpSellerStorePromiseTemplate promiseTemplate = erpSellerStorePromiseTemplateMapper.selectOne(proLqw);
//        if (promiseTemplate == null) {
//            uploadTestTask.setRemark("店铺没有合适的服务模板");
//            uploadTestTask.setStatus(3);
//            map.put("uploadTestTask", uploadTestTask);
//            map.put("code", 500);
//            return map;
//        }
//        map.put("promise_template_id", promiseTemplate.getTemplateId());
//
//        // 运费模板
//        String mbName = "";
//        if (quotationCurrency.equals("USD")) { // 美元
//            mbName = "P3普货不包邮";
//        } else { // 人民币
//            mbName = "P3普货人民币不包邮";
//        }
//        // 根据店铺id和固定模板名字获取运费模板id
//        LambdaQueryWrapper<ErpSellerStoreFreightTemplate> freLqw = new LambdaQueryWrapper<ErpSellerStoreFreightTemplate>();
//        freLqw.eq(ErpSellerStoreFreightTemplate::getSellerStoreId, storeId);
//        freLqw.like(ErpSellerStoreFreightTemplate::getTemplateName, mbName);
//        freLqw.last("limit 1");
//        ErpSellerStoreFreightTemplate freightTemplate = erpSellerStoreFreightTemplateMapper.selectOne(freLqw);
//        if (freightTemplate == null) {
//            uploadTestTask.setRemark("店铺没有合适的运费模板，美元店铺需有‘P3普货不包邮’，人民币店铺需有‘P3普货人民币不包邮’");
//            uploadTestTask.setStatus(3);
//            map.put("uploadTestTask", uploadTestTask);
//            map.put("code", 500);
//            return map;
//        }
//        map.put("freight_template_id", freightTemplate.getTemplateId());
//
//        // 商品多语言标题
//        AeProductPost.ErpProductSubject subject = new AeProductPost.ErpProductSubject();
//        subject.setLocale("en_US");
//        subject.setValue(product.getSubject());
//        List<AeProductPost.ErpProductSubject> subjectList = new ArrayList<>();
//        subjectList.add(subject);
//        map.put("subject_list", subjectList);
//
//        // aeop_ae_product_s_k_us sku信息
//        // 创造必要变量
//        List<AeProductPost.AeopAeProductSKUs> aeSkuList = new ArrayList<>();
//        AeProductPost.AeopAeProductSKUs aeSku = new AeProductPost.AeopAeProductSKUs();
//        ErpCollectProductSku collectSku = new ErpCollectProductSku();
//        List<AeProductPost.SkuNationalDiscountPrice> skuNationalDiscountPrice = new ArrayList<>();
//        AeProductPost.SkuNationalDiscountPrice discountPrice = new AeProductPost.SkuNationalDiscountPrice();
//        List<AeProductPost.AeopSKUProperty> aeopSKUPropertyList = new ArrayList<>();
//        AeProductPost.AeopSKUProperty skuProperty = new AeProductPost.AeopSKUProperty();
//        BigDecimal newUsdExchange = iErpUsdExchangeService.getNewUsdExchange();
//
//        // 获取商品sku属性
//        String skuProperty1 = expend.getSkuProperty();
//        List<Dict> skuPropertyList = JsonUtils.parseArrayMap(skuProperty1);
//        // 创建属性对应map
//        Map<String, String> skuPropertyMap = new HashMap<>();
//        Dict dict = skuPropertyList.get(0);
//        List<Map<String, Object>> propertyList = (List<Map<String, Object>>) dict.get("list");
//        for (Map<String, Object> propertyMap : propertyList) {
//            skuPropertyMap.put(propertyMap.get("value") + "", propertyMap.get("name") + "");
//        }
//
//        // 进入循环
//        if (skuList.size() != 0) {
//            for (ErpCollectProductSku sellerSku : skuList) {
//                // 直接转换
//                String skuPropertyIds = sellerSku.getSkuPropertyIds();
//                String[] split = skuPropertyIds.split(";");
//
//                // 添加属性
//                List<Map<String, Object>> list = new LinkedList<Map<String, Object>>();
//                for (int i = 0; i < split.length; i++) {
//                    String string2 = split[i];
//                    String[] split2 = string2.split(":");
//                    Map<String, Object> map1 = new HashMap<String, Object>();
//                    if (i == 0) {
//                        map1.put("property_value_definition_name", skuPropertyMap.get(split2[1]));
//                        map1.put("sku_image", sellerSku.getSkuImage());
//                    }
//                    map1.put("property_value_id", split2[1]);
//                    map1.put("sku_property_id", split2[0]);
//                    list.add(map1);
//
//                }
//                String skuProperty2 = JsonUtils.toJsonString(list);
//                sellerSku.setSkuProperty(skuProperty2);
//            }
//            // 进行图片银行的上传
//            Map<String, Object> productMap = getAllPicByProductId(product, storeId, skuList, type);
//            if ((Integer) productMap.get("code") == 200) {
//                skuList = (List<ErpCollectProductSku>) productMap.get("skuList");
//                product = (ErpCollectProduct) productMap.get("product");
//            } else {
//                Integer code = (Integer) productMap.get("code");
//                String msg = (String) productMap.get("msg");
//                uploadTestTask.setRemark(msg);
//                map.put("code", code);
//                map.put("uploadTestTask", uploadTestTask);
//                return map;
//            }
//
//            // 第二次循环
//            for (ErpCollectProductSku sellerSku : skuList) {
//
//                aeSku = new AeProductPost.AeopAeProductSKUs();
//                Long skuStock = sellerSku.getSkuStock();
//                if (ObjectUtils.isNull(sellerSku.getSkuStock())) {
//                    aeSku.setIpm_sku_stock(0L);
//                    skuStock = 0L;
//                } else {
//                    aeSku.setIpm_sku_stock(sellerSku.getSkuStock());
//                }
//                if (skuStock > 0) {
//                    aeSku.setSku_stock("true");
//                } else {
//                    aeSku.setSku_stock("false");
//                }
//                aeSku.setSku_code(sellerSku.getSkuCode());
//
//                // 获取SKU采集表对应值
//                aeSku.setGross_weight(sellerSku.getSkuWeight().toString());
//                aeSku.setPackage_height(sellerSku.getSkuHeight().intValue());
//                aeSku.setPackage_width(sellerSku.getSkuWidth().intValue());
//                aeSku.setPackage_length(sellerSku.getSkuLength().intValue());
//                aeSku.setCurrency_code(quotationCurrency);
//                // 换算价格
//                // 如果店铺是USD账户，则进行换算，如果不是则不换算
//                BigDecimal skuConversionPrice = BigDecimal.valueOf(0);
//                if (quotationCurrency.equals("USD")) {
//                    skuConversionPrice = BigDecimal.valueOf(Double.valueOf(sellerSku.getSkuPrice()))
//                            .multiply(BigDecimal.valueOf(100)).divide(newUsdExchange, BigDecimal.ROUND_CEILING);
//                    aeSku.setSku_price(skuConversionPrice.toString());
//                } else {
//                    aeSku.setSku_price(sellerSku.getSkuPrice());
//                }
//
//                // 获取SKU采集表对应值
////                aeSku.setGross_weight(sellerSku.getSkuWeight().toString());
////                aeSku.setPackage_height(sellerSku.getSkuHeight().intValue());
////                aeSku.setPackage_width(sellerSku.getSkuWidth().intValue());
////                aeSku.setPackage_length(sellerSku.getSkuLength().intValue());
////                collectSku = erpCollectProductSkuMapper.selectOne(new LambdaQueryWrapper<ErpCollectProductSku>().eq(ErpCollectProductSku::getSkuCode, sellerSku.getSkuCode()));
//
//                List<AeProductPost.AeopSKUProperty> skuPropertyList2 = JSONArray.parseArray(sellerSku.getSkuProperty(),
//                        AeProductPost.AeopSKUProperty.class);
//                aeSku.setAeop_s_k_u_property(skuPropertyList2);
//                aeSku.setId(sellerSku.getSkuPropertyIds());
//                aeSkuList.add(aeSku);
//            }
//            aeProductPost.setAeop_ae_product_s_k_us(aeSkuList);
//        } else {
//            Map<String, Object> productMap = getAllPicByProductId(product, storeId, skuList, type);
//            if ((Integer) productMap.get("code") == 200) {
//                skuList = (List<ErpCollectProductSku>) productMap.get("skuList");
//                product = (ErpCollectProduct) productMap.get("product");
//            } else {
//                Integer code = (Integer) productMap.get("code");
//                switch (code) {
//                    case 500:
//                        uploadTestTask.setRemark("商品上传图片银行异常");
//                        map.put("code", 500);
//                        map.put("uploadTestTask", uploadTestTask);
//                        return map;
//                    case 501:
//                        // 详情图异常
//                        uploadTestTask.setRemark("商品主图异常");
//                        map.put("code", 501);
//                        map.put("uploadTestTask", uploadTestTask);
//                        return map;
//                    case 502:
//                        uploadTestTask.setRemark("商品营销图异常");
//                        map.put("code", 501);
//                        map.put("uploadTestTask", uploadTestTask);
//                        return map;
//                    case 503:
//                        uploadTestTask.setRemark("商品白底图异常");
//                        map.put("code", 502);
//                        map.put("uploadTestTask", uploadTestTask);
//                        return map;
//                    case 504:
//                        uploadTestTask.setRemark("商品轮播图异常");
//                        map.put("code", 503);
//                        map.put("uploadTestTask", uploadTestTask);
//                        return map;
//
//                }
//            }
//
//        }
//        map.put("aeop_ae_product_s_k_us", aeProductPost.getAeop_ae_product_s_k_us());
//
//        // 主图(需要上传银行)
//        if (product.getImageURLs() == null) {
//            map.put("image_u_r_ls", "[]");
//        } else {
//            map.put("image_u_r_ls", product.getImageURLs());
//        }
//        // detail_source_list 商品详描
//        List<AeProductPost.DetailSourceList> detailSourceList = new ArrayList<>();
//        AeProductPost.DetailSourceList detailSource = new AeProductPost.DetailSourceList();
//        String makeDetail = null;
////        if (ObjectUtils.isNull(product.getOldDetailImg())) {
//        makeDetail = makeDetail(product.getDetail(), product.getDetailImg());
////        } else {
////            makeDetail = makeDetail(product.getDetail(), product.getOldDetailImg());
////        }
//        detailSource.setMobile_detail(makeDetail);
//        detailSource.setWeb_detail(makeDetail);
//        detailSource.setLocale("en_US");
//        detailSourceList.add(detailSource);
//        map.put("detail_source_list", detailSourceList);
//        // 获取欧盟负责人
//        String euResponsiblePersonByCategoryId = aeProductService.getEUResponsiblePersonByCategoryId(categoryId,
//                storeId, 1);
//        if (euResponsiblePersonByCategoryId != null) {
//            map.put("msr_eu_id", euResponsiblePersonByCategoryId);
//        }
//
//        // aeop_ae_product_propertys 产性品属
//        String s = "";
//        // 添加商品的品牌
//        List<Aliexpress.ValueVo> valueList = aliexpressCategoryServiceImpl.getBrandById(product.getCategoryId(),
//                storeId);
//        if (valueList == null || valueList.size() == 0) {
//            uploadTestTask.setRemark("测试店铺没有该类目的品牌");
//            map.put("code", 503);
//            map.put("uploadTestTask", uploadTestTask);
//            return map;
//        }
//        Aliexpress.ValueVo valueVo = valueList.get(0);
//        s = "[{\"attr_name\":\"" + valueVo.getAttr_value() + "\",\"attr_name_id\":2,\"attr_value_id\":"
//                + valueVo.getAttr_value_id() + "},";
//        String customAttributes = product.getCustomAttributes();
//        if (ObjectUtils.isNotNull(customAttributes)) {
//            customAttributes = customAttributes.replaceFirst("\\[", s);
//            map.put("aeop_ae_product_propertys", customAttributes);
//        }
//
//        // 区域定价
//        String absoluteQuoteMapStr = expend.getAbsoluteQuoteMap();
//        if (ObjectUtils.isNotNull(absoluteQuoteMapStr)) {
//            List<Dict> absoluteQuoteMapList = JsonUtils.parseArrayMap(absoluteQuoteMapStr);
//            // 获取运费，换算金额
//            for (Dict dict1 : absoluteQuoteMapList) {
//                Map<String, Double> absoluteQuoteMap = (Map) dict1.get("absoluteQuoteMap");
//                for (String key : absoluteQuoteMap.keySet()) {
//                    BigDecimal amount = new BigDecimal(absoluteQuoteMap.get(key));
//                    // 换算价格
//                    if (quotationCurrency.equals("USD")) {
//                        BigDecimal res = amount.multiply(BigDecimal.valueOf(100)).divide(newUsdExchange,
//                                BigDecimal.ROUND_CEILING);
//                        absoluteQuoteMap.put(key, res.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
//                    } else {
//                        absoluteQuoteMap.put(key, amount.doubleValue());
//                    }
//                    // 只保留两位小数
//                }
//            }
//            // 获取完成的区域定价
//            absoluteQuoteMapStr = JsonUtils.toJsonString(absoluteQuoteMapList);
//            String configuration = absoluteQuoteMapStr.replace("\\", "");
//            AeProductPost.AeopNationalQuoteConfiguration ational_quote_configuration = new AeProductPost.AeopNationalQuoteConfiguration();
//            ational_quote_configuration.setConfiguration_data(configuration);
//            ational_quote_configuration.setConfiguration_type("absolute");
//            map.put("aeop_national_quote_configuration", ational_quote_configuration);
//        }
//
//
//        // 营销图和白底图
//        List<AeProductPost.MarketImages> marketImagesList = new ArrayList<>();
//        AeProductPost.MarketImages marketImages = new AeProductPost.MarketImages();
//        // 营销图
//        marketImages.setUrl(product.getMarketing());
//        marketImages.setImage_type(1);
//        marketImagesList.add(marketImages);
//        // 白底图
//        AeProductPost.MarketImages whiteImages = new AeProductPost.MarketImages();
//        whiteImages.setUrl(product.getWhite());
//        whiteImages.setImage_type(2);
//        marketImagesList.add(whiteImages);
//        map.put("market_images", marketImagesList);
//        // 视频
////        map.put("aeop_a_e_multimedia", aeProductPost.getAeop_a_e_multimedia());
//        map.put("code", 200);
//        return map;
//    }


//    /**
//     * 快速测试发布
//     *
//     * @param collectProductId
//     * @param type
//     * @return
//     */
//    public R<Object> kakaProductUploadTestQuick(Long collectProductId, Integer type) {
//// 获取
//        LambdaQueryWrapper<ErpKakaCollectProductUploadTestTask> lqw = new LambdaQueryWrapper<ErpKakaCollectProductUploadTestTask>();
////        lqw.eq(ErpCollectProductUploadTestTask::getStatus, 0);
//        lqw.eq(ErpKakaCollectProductUploadTestTask::getCollectProductId, collectProductId);
////        lqw.eq(ErpCollectProductUploadTestTask::getType, type);
//        lqw.orderByDesc(ErpKakaCollectProductUploadTestTask::getAddTime);
//        lqw.last(" limit 1");
//        ErpKakaCollectProductUploadTestTask task = baseMapper.selectOne(lqw);
//        if (task == null) {
//            return R.fail("暂无需要发布商品");
//        }
//        task.setStatus(1);
//        task.setTestTime(new Date());
//        baseMapper.updateById(task);
//        //公共产品发布测试
//        task = collectProductUploadTest(task, 1);
//        if (task.getStatus() == 1) {
//            task.setStatus(3);
//            task.setRemark("未执行");
//        }
//        //清除还为0的重复运费试算的记录
//        baseMapper.updateById(task);
//        List<ErpKakaCollectProductUploadTestTask> erpCollectProductUploadTestTasks = baseMapper.selectList(
//                new LambdaQueryWrapper<ErpKakaCollectProductUploadTestTask>()
//                        .eq(ErpKakaCollectProductUploadTestTask::getCollectProductId, collectProductId)
//                        .eq(ErpKakaCollectProductUploadTestTask::getStatus, 0)
//        );
//        List<Long> collectIds = erpCollectProductUploadTestTasks.stream().map(ErpCollectProductUploadTestTask -> ErpCollectProductUploadTestTask.getId()).collect(Collectors.toList());
//        if (collectIds.size() != 0) {
//            baseMapper.deleteBatchIds(collectIds);
//        }
//        return R.ok("测试发布完成");
//    }
//
//    /**
//     * 公共采集库测试发布
//     *
//     * @param task
//     * @param type
//     * @return
//     */
//    public ErpKakaCollectProductUploadTestTask collectProductUploadTest(ErpKakaCollectProductUploadTestTask task, Integer type) {
//        // 获取商品
//        ErpKakaCollectProduct product = .selectById(task.getCollectProductId());
//        if (product == null) {
//            task.setRemark("该商品状态异常");
//            task.setStatus(3);
//            return task;
//        }
//        Long productId = product.getId();
//        // 公共商品延伸
//        ErpKakaCollectProductExpand expand = erpKakaCollectProductExpandMapper
//                .selectOne(new LambdaQueryWrapper<ErpKakaCollectProductExpand>()
//                        .eq(ErpKakaCollectProductExpand::getCollectProductId, product.getId()).last(" limit 1 "));
//        // 公共产品sku列表
//        List<ErpKakaCollectProductSku> skuList = erpKakaCollectProductSkuMapper
//                .selectList(new LambdaQueryWrapper<ErpKakaCollectProductSku>().eq(ErpKakaCollectProductSku::getCollectProductId,
//                        productId));
//
//        task = iErpKakaCollectProductUploadTestTaskService.disposeKakaUploadTest(task, type, product, expand, skuList);
//
//        baseMapper.updateById(task);
//        expand = erpKakaCollectProductExpandMapper.selectOne(new LambdaQueryWrapper<ErpKakaCollectProductExpand>()
//                .eq(ErpKakaCollectProductExpand::getCollectProductId, productId));
//        expand.setIsUploadTest(task.getStatus().longValue());
//        erpKakaCollectProductExpandMapper.updateById(expand);
//        return task;
//    }


}
